home *** CD-ROM | disk | FTP | other *** search
/ Mac Magazin/MacEasy 43 / Mac Magazin and MacEasy Magazine CD - Issue 43.iso / Software / Multimedia / Sound / PlayerPRO 4.6 Dev.Kit / MADH Library 4.6 / MADLibrary Source / DelayOutPut.c < prev    next >
Encoding:
Text File  |  1998-01-23  |  20.8 KB  |  716 lines  |  [TEXT/CWIE]
  1. /********************                        ***********************/
  2. //
  3. //    Player PRO 4.6 - DRIVER SOURCE CODE -
  4. //
  5. //    Library Version 4.6
  6. //
  7. //    To use with MAD Library for Mac: Symantec, CodeWarrior and MPW
  8. //
  9. //    Antoine ROSSET
  10. //    16 Tranchees
  11. //    1206 GENEVA
  12. //    SWITZERLAND
  13. //
  14. //    COPYRIGHT ANTOINE ROSSET 1996, 1997, 1998
  15. //
  16. //    Thank you for your interest in PlayerPRO !
  17. //
  18. //    FAX:            (+41 22) 346 11 97
  19. //    PHONE:             (+41 79) 203 74 62
  20. //    Internet:         rosset@dial.eunet.ch or RossetAntoine@bluewin.ch
  21. //
  22. /********************                        ***********************/
  23.  
  24. #include "RDriver.h"
  25. #include "RDriverInt.h"
  26.  
  27. void Sampler16AddDelay( Channel *curVoice, long    *ASCBuffer, MADDriverRec *intDriver)
  28. {
  29.     Ptr                    SndBuffer;
  30.     short                *VolPtr, *VolPtr2;
  31.     long                LRVol = intDriver->LeftRight[ curVoice->ID], i = intDriver->ASCBUFFER;
  32.     Byte                tByte = 0;
  33.     long                *ASCBuffer1, *ASCBuffer2;
  34.  
  35.     ///
  36.     long                aDD, aCC = curVoice->lAC, off;
  37.     
  38.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  39.     ///
  40.     
  41.     
  42.     VolPtr2            = (short*) ( intDriver->Vol + (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8) * 2L);
  43.     LRVol = 100 - LRVol;
  44.     VolPtr            = (short*) ( intDriver->Vol + (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8) * 2L);
  45.     
  46.     if( LRVol > 50)
  47.     {
  48.         ASCBuffer1 = ASCBuffer;
  49.         ASCBuffer2 = ASCBuffer +1L + intDriver->MDelay*2L;
  50.     }
  51.     else
  52.     {
  53.         ASCBuffer2 = ASCBuffer +1L;
  54.         ASCBuffer1 = ASCBuffer + intDriver->MDelay*2L;
  55.     }
  56.  
  57.     //*****************************************
  58.     //*****************************************
  59.     //*****************************************
  60.     if( intDriver->DriverSettings.TickRemover) MADTickRemoverStart8( curVoice, ASCBuffer1, ASCBuffer2, intDriver);
  61.     //*****************************************
  62.     //*****************************************
  63.     //*****************************************
  64.     
  65.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  66.     
  67.     SndBuffer        = curVoice->curPtr;
  68.     
  69.     if( SndBuffer + 1 + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  70.     {
  71.         if( intDriver->DriverSettings.Interpolation)
  72.         {
  73.             long    RightWeight, LeftWeight;
  74.             
  75.             while( i-- > 0)
  76.             {
  77.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;        off = (long) (aCC>>BYTEDIV);
  78.                 
  79.                 if( SndBuffer + off + 1 >= curVoice->maxPtr)
  80.                 {
  81.                     if( curVoice->loopSize > 0) 
  82.                     {
  83.                         long    before;
  84.                         
  85.                         if( i >= intDriver->ASCBUFFER-1)
  86.                         {
  87.                             before = curVoice->lastWord >> 8;
  88.                         }
  89.                         else
  90.                         {
  91.                             aCC -= aDD;
  92.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  93.                             aCC += aDD;
  94.                         }
  95.                         
  96.                         SndBuffer -= curVoice->loopSize;
  97.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  98.                         
  99.                         //*****************************************
  100.                         //*****************************************
  101.                         //*****************************************
  102.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop8( i, curVoice, ASCBuffer1, ASCBuffer2, intDriver, before - *(SndBuffer + off));
  103.                         //*****************************************
  104.                         //*****************************************
  105.                         //*****************************************
  106.                         
  107.                     }
  108.                     else    // If TICK remove
  109.                     {
  110.                         
  111.                         //*****************************************
  112.                         //*****************************************
  113.                         //*****************************************
  114.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer1, ASCBuffer2, i, *(VolPtr + tByte), *(VolPtr2 + tByte));
  115.                         //*****************************************
  116.                         //*****************************************
  117.                         //*****************************************
  118.                         
  119.                         break;
  120.                     }
  121.                 }
  122.                 
  123.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  124.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  125.                 
  126.                 *ASCBuffer1 += *(VolPtr  + tByte);    ASCBuffer1 += 2;
  127.                 *ASCBuffer2 += *(VolPtr2  + tByte);    ASCBuffer2 += 2;
  128.             }
  129.         }
  130.         else
  131.         {
  132.             while( i-- > 0)
  133.             {
  134.                 off = (long) (aCC>>BYTEDIV);
  135.                 if( SndBuffer + off >= curVoice->maxPtr)
  136.                 {
  137.                     if( curVoice->loopSize > 0) 
  138.                     {
  139.                         long    before;
  140.                         
  141.                         if( i >= intDriver->ASCBUFFER-1) before = curVoice->lastWord >> 8;
  142.                         else
  143.                         {
  144.                             aCC -= aDD;
  145.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  146.                             aCC += aDD;
  147.                         }
  148.                         
  149.                         SndBuffer -= curVoice->loopSize;
  150.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  151.                         
  152.                         //*****************************************
  153.                         //*****************************************
  154.                         //*****************************************
  155.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop8( i, curVoice, ASCBuffer1, ASCBuffer2, intDriver, before - *(SndBuffer + off));
  156.                         //*****************************************
  157.                         //*****************************************
  158.                         //*****************************************
  159.                     }
  160.                     else    // If TICK remove
  161.                     {
  162.                         //*****************************************
  163.                         //*****************************************
  164.                         //*****************************************
  165.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer1, ASCBuffer2, i, *(VolPtr + tByte), *(VolPtr2 + tByte));
  166.                         //*****************************************
  167.                         //*****************************************
  168.                         //*****************************************
  169.                         
  170.                         break;
  171.                     }
  172.                 }
  173.                 
  174.                 tByte = (Byte) *(SndBuffer + off);        aCC += aDD;
  175.                 *ASCBuffer1 += *(VolPtr  + tByte);    ASCBuffer1 += 2;
  176.                 *ASCBuffer2 += *(VolPtr2  + tByte);    ASCBuffer2 += 2;
  177.             }
  178.         }
  179.         
  180.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  181.         else
  182.         {
  183.             curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;
  184.         }
  185.     }
  186.     else
  187.     {
  188.         if( intDriver->DriverSettings.Interpolation)
  189.         {
  190.             long    RightWeight, LeftWeight;
  191.             
  192.             while( i-- > 0)
  193.             {
  194.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;        off = (long) (aCC>>BYTEDIV);
  195.                 
  196.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  197.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  198.                 
  199.                 *ASCBuffer1 += *(VolPtr  + tByte);    ASCBuffer1 += 2;
  200.                 *ASCBuffer2 += *(VolPtr2  + tByte);    ASCBuffer2 += 2;
  201.             }
  202.         }
  203.         else
  204.         {
  205.             while( i-- > 0)
  206.             {
  207.                 tByte = (Byte) *(SndBuffer + (long) (aCC>>BYTEDIV));            aCC += aDD;
  208.                 *ASCBuffer1 += *(VolPtr  + tByte);    ASCBuffer1 += 2;
  209.                 *ASCBuffer2 += *(VolPtr2  + tByte);    ASCBuffer2 += 2;
  210.             }
  211.         }
  212.         
  213.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  214.     }
  215.     
  216.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  217.     
  218.     aCC -= aDD;
  219.     curVoice->lastWord = *(SndBuffer + (long) (aCC>>BYTEDIV));
  220.     curVoice->lastWord <<= 8;
  221. }
  222.  
  223. void Sampler16Addin16Delay( Channel *curVoice, long    *ASCBuffer, MADDriverRec *intDriver)
  224. {
  225.     long                i = intDriver->ASCBUFFER;
  226.     short                *SndBuffer, tShort;
  227.     long                LRVol = intDriver->LeftRight[ curVoice->ID], chnVol, chnVol2;
  228.     long                off;
  229.     long                *ASCBuffer1, *ASCBuffer2;
  230.     
  231.     ///
  232.     long                aDD, aCC = curVoice->lAC;
  233.     
  234.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  235.     ///
  236.     
  237.     chnVol2        = ((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ REDUCEVOLUME);
  238.     LRVol = 100 - LRVol;
  239.     chnVol         = ((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ REDUCEVOLUME);
  240.     if( LRVol > 50)
  241.     {
  242.         ASCBuffer1 = ASCBuffer;
  243.         ASCBuffer2 = ASCBuffer +1L + intDriver->MDelay*2L;
  244.     }
  245.     else
  246.     {
  247.         ASCBuffer2 = ASCBuffer +1L;
  248.         ASCBuffer1 = ASCBuffer + intDriver->MDelay*2L;
  249.     }
  250.  
  251.     //*****************************************
  252.     //*****************************************
  253.     //*****************************************
  254.     if( intDriver->DriverSettings.TickRemover) MADTickRemoverStart8( curVoice, ASCBuffer1, ASCBuffer2, intDriver);
  255.     //*****************************************
  256.     //*****************************************
  257.     //*****************************************
  258.  
  259.     
  260.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  261.  
  262.     SndBuffer        = (short*)    curVoice->curPtr;
  263.     
  264.     if( SndBuffer + 1L + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= (  short*) curVoice->maxPtr)
  265.     {
  266.         if( intDriver->DriverSettings.Interpolation)
  267.         {
  268.             long    RightWeight, LeftWeight;
  269.             
  270.             while( i-- > 0)
  271.             {
  272.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  273.                 
  274.                 off = (aCC>>BYTEDIV);
  275.                 if( SndBuffer + off + 1 >= (short*) curVoice->maxPtr)
  276.                 {
  277.                     if( curVoice->loopSize > 0) 
  278.                     {
  279.                         long    before;
  280.                         
  281.                         if( i >= intDriver->ASCBUFFER-1)
  282.                         {
  283.                             before = curVoice->lastWord;
  284.                         }
  285.                         else
  286.                         {
  287.                             aCC -= aDD;
  288.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  289.                             aCC += aDD;
  290.                         }
  291.                         
  292.                         SndBuffer -= curVoice->loopSize/2;
  293.                         if( SndBuffer + off < (short*) curVoice->begPtr) SndBuffer = (short*) curVoice->begPtr - off;
  294.                         
  295.                         //*****************************************
  296.                         //*****************************************
  297.                         //*****************************************
  298.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop16( i, curVoice, ASCBuffer1, ASCBuffer2, intDriver, before - *(SndBuffer + off));
  299.                         //*****************************************
  300.                         //*****************************************
  301.                         //*****************************************
  302.                         
  303.                     }
  304.                     else    // If TICK remove
  305.                     {
  306.                         
  307.                         //*****************************************
  308.                         //*****************************************
  309.                         //*****************************************
  310.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer1, ASCBuffer2, i, (tShort * chnVol) >> 6, (tShort * chnVol2) >> 6);
  311.                         //*****************************************
  312.                         //*****************************************
  313.                         //*****************************************
  314.                         
  315.                         break;
  316.                     }
  317.                 }
  318.                 tShort = (    LeftWeight *     *(SndBuffer + off) +
  319.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  320.                 
  321.                 *ASCBuffer1 += (tShort * chnVol) >> 6;        ASCBuffer1 += 2;
  322.                 *ASCBuffer2 += (tShort * chnVol2) >> 6;        ASCBuffer2 += 2;
  323.             }
  324.         }
  325.         else
  326.         {
  327.             while( i-- > 0)
  328.             {
  329.                 off = (aCC>>BYTEDIV);
  330.                 if( SndBuffer + off >= (short*) curVoice->maxPtr)
  331.                 {
  332.                     if( curVoice->loopSize > 0) 
  333.                     {
  334.                         long    before;
  335.                         
  336.                         if( i >= intDriver->ASCBUFFER-1)
  337.                         {
  338.                             before = curVoice->lastWord;
  339.                         }
  340.                         else
  341.                         {
  342.                             aCC -= aDD;
  343.                             before = *(SndBuffer + (aCC>>BYTEDIV));
  344.                             aCC += aDD;
  345.                         }
  346.                         
  347.                         SndBuffer -= curVoice->loopSize/2;
  348.                         if( SndBuffer + off < (short*) curVoice->begPtr) SndBuffer = (short*) curVoice->begPtr - off;
  349.                         
  350.                         //*****************************************
  351.                         //*****************************************
  352.                         //*****************************************
  353.                         if( intDriver->DriverSettings.TickRemover) MADTickRemoverLoop16( i, curVoice, ASCBuffer1, ASCBuffer2, intDriver, before - *(SndBuffer + off));
  354.                         //*****************************************
  355.                         //*****************************************
  356.                         //*****************************************
  357.                         
  358.                     }
  359.                     else    // If TICK remove
  360.                     {
  361.                         
  362.                         //*****************************************
  363.                         //*****************************************
  364.                         //*****************************************
  365.                         if( intDriver->DriverSettings.TickRemover) MADTickLoopFill8( curVoice, ASCBuffer1, ASCBuffer2, i, (tShort * chnVol) >> 6, (tShort * chnVol2) >> 6);
  366.                         //*****************************************
  367.                         //*****************************************
  368.                         //*****************************************
  369.                         
  370.                         break;
  371.                     }
  372.                 }
  373.                 tShort = *(SndBuffer + off);        aCC += aDD;
  374.                 
  375.                 *ASCBuffer1 += (tShort * chnVol) >> 6;        ASCBuffer1 += 2;
  376.                 *ASCBuffer2 += (tShort * chnVol2) >> 6;        ASCBuffer2 += 2;
  377.             }
  378.         }
  379.         
  380.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  381.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  382.     }
  383.     else
  384.     {
  385.         if( intDriver->DriverSettings.Interpolation)
  386.         {
  387.             long    RightWeight, LeftWeight;
  388.             
  389.             while( i-- > 0)
  390.             {
  391.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  392.                 
  393.                 off = (aCC>>BYTEDIV);
  394.                 tShort = (    LeftWeight *     *(SndBuffer + off) +
  395.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  396.             
  397.                 *ASCBuffer1 += (tShort * chnVol) >> 6;        ASCBuffer1 += 2;
  398.                 *ASCBuffer2 += (tShort * chnVol2) >> 6;        ASCBuffer2 += 2;
  399.             }
  400.         }
  401.         else
  402.         {
  403.             while( i-- > 0)
  404.             {
  405.                 off = (aCC>>BYTEDIV);
  406.                 tShort = *(SndBuffer + off);        aCC += aDD;
  407.                 
  408.                 *ASCBuffer1 += (tShort * chnVol) >> 6;        ASCBuffer1 += 2;
  409.                 *ASCBuffer2 += (tShort * chnVol2) >> 6;        ASCBuffer2 += 2;
  410.             }
  411.         }
  412.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  413.     }
  414.     
  415.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  416.     
  417.     aCC -= aDD;
  418.     curVoice->lastWord = *(SndBuffer + (long) (aCC>>BYTEDIV));
  419. }
  420.  
  421. void Sample16BufferAddDelay( Channel *curVoice, register long    *ASCBuffer, MADDriverRec *intDriver)
  422. {
  423.     if( curVoice->amp == 16) Sampler16Addin16Delay( curVoice, ASCBuffer, intDriver);
  424.     else if( curVoice->amp == 8) Sampler16AddDelay( curVoice, ASCBuffer, intDriver);
  425. }
  426.  
  427. void Play16StereoDelay( MADDriverRec *intDriver)
  428. {
  429. short        *ASCBuffer, valP = 0x7FFFL, valN = -0x7FFFL;
  430. long        *ttt, i;
  431.  
  432.     for( i = 0 ; i < intDriver->DriverSettings.numChn; i++) Sample16BufferAddDelay( &intDriver->chan[ i], intDriver->DASCBuffer, intDriver);
  433.     
  434.     ttt = intDriver->DASCBuffer;
  435.     ASCBuffer = (short*) intDriver->IntDataPtr;
  436.     
  437.     i = intDriver->ASCBUFFER*2;
  438.     
  439.     while( i-- > 0)
  440.     {
  441.         if( *ttt > valP) *ASCBuffer++ = valP;
  442.         else if( *ttt < valN) *ASCBuffer++ = valN;
  443.         else *ASCBuffer++ = *ttt;
  444.         
  445.         *ttt++ = 0;
  446.     }
  447. }
  448.  
  449. void Sampler8in8AddDelay( Channel *curVoice, short    *ASCBuffer, MADDriverRec *intDriver)
  450. {
  451.     char             *SndBuffer;
  452.     Byte            tByte;
  453.     long             i = intDriver->ASCBUFFER, LRVol = intDriver->LeftRight[ curVoice->ID];
  454.     Ptr                VolPtr, VolPtr2;
  455.     long            off;
  456.     short            *ASCBuffer1, *ASCBuffer2;
  457.  
  458.     ///
  459.     long                aDD, aCC = curVoice->lAC;
  460.     
  461.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  462.     ///
  463.     
  464.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  465.     
  466.     SndBuffer        = (char*)     curVoice->curPtr;
  467.     
  468.     VolPtr2            = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  469.     LRVol = 100 - LRVol;
  470.     VolPtr             = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  471.     if( LRVol > 50)
  472.     {
  473.         ASCBuffer1 = ASCBuffer;
  474.         ASCBuffer2 = ASCBuffer +1L + intDriver->MDelay*2L;
  475.     }
  476.     else
  477.     {
  478.         ASCBuffer2 = ASCBuffer +1L;
  479.         ASCBuffer1 = ASCBuffer + intDriver->MDelay*2L;
  480.     }
  481.     
  482.     if( (Ptr) SndBuffer + 1L + (long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  483.     {
  484.         if( intDriver->DriverSettings.Interpolation)
  485.         {
  486.             long    RightWeight, LeftWeight;
  487.             
  488.             while( i-- > 0)
  489.             {
  490.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  491.                 
  492.                 off = aCC>>BYTEDIV;
  493.                 if( SndBuffer + off + 1L >= (char*) curVoice->maxPtr)
  494.                 {
  495.                     if( curVoice->loopSize > 0) 
  496.                     {
  497.                         SndBuffer -= curVoice->loopSize;
  498.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  499.                     }
  500.                     else break;
  501.                 }
  502.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  503.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  504.                 
  505.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  506.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  507.             }
  508.         }
  509.         else
  510.         {
  511.             while( i-- > 0)
  512.             {
  513.                 off = aCC>>BYTEDIV;
  514.                 if( SndBuffer + off + 1L >= (char*) curVoice->maxPtr)
  515.                 {
  516.                     if( curVoice->loopSize > 0) 
  517.                     {
  518.                         SndBuffer -= curVoice->loopSize;
  519.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  520.                     }
  521.                     else break;
  522.                 }
  523.                 tByte =    *(SndBuffer + off);            aCC += aDD;
  524.             
  525.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  526.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  527.             }
  528.         }
  529.         
  530.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  531.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  532.     }
  533.     else
  534.     {
  535.         if( intDriver->DriverSettings.Interpolation)
  536.         {
  537.             long    RightWeight, LeftWeight;
  538.             
  539.             while( i-- > 0)
  540.             {
  541.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  542.                 
  543.                 off = aCC>>BYTEDIV;
  544.                 tByte = (    LeftWeight *     *(SndBuffer + off) +
  545.                             RightWeight *     *(SndBuffer + off + 1)) >> BYTEDIV;            aCC += aDD;
  546.             
  547.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  548.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  549.             }
  550.         }
  551.         else
  552.         {
  553.             while( i-- > 0)
  554.             {
  555.                 off = aCC>>BYTEDIV;
  556.                 tByte =    *(SndBuffer + off);            aCC += aDD;
  557.             
  558.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  559.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  560.             }
  561.         }
  562.         
  563.         curVoice->curPtr = (Ptr) (SndBuffer + (long) (aCC>>BYTEDIV));
  564.     }
  565.     
  566.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  567. }
  568.  
  569. void Sampler8in16AddDelay( Channel *curVoice, short    *ASCBuffer, MADDriverRec *intDriver)
  570. {
  571.     char                 *SndBuffer;
  572.     Byte                tByte;
  573.     Ptr                    VolPtr, VolPtr2;
  574.     long                i = intDriver->ASCBUFFER, LRVol = intDriver->LeftRight[ curVoice->ID];
  575.     long                off;
  576.     short                *ASCBuffer1, *ASCBuffer2;
  577.     
  578.     ///
  579.     long                aDD, aCC = curVoice->lAC;
  580.     
  581.     aDD = (AMIGA_CLOCKFREQ2 << BYTEDIV) / ( curVoice->period * (intDriver->DriverSettings.outPutRate>>16));
  582.     ///
  583.  
  584.     
  585.     if( curVoice->curPtr >= curVoice->maxPtr && curVoice->loopSize == 0) return;
  586.     
  587.     SndBuffer        = (char*) curVoice->curPtr;
  588.  
  589.     
  590.     VolPtr2            = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  591.     LRVol = 100 - LRVol;
  592.     VolPtr             = (Ptr)     ( intDriver->Vol + (long) (((DoVol( curVoice) * intDriver->VolExt[ curVoice->ID] * LRVol)/ (REDUCEVOLUME)) << 8));
  593.     if( LRVol > 50)
  594.     {
  595.         ASCBuffer1 = ASCBuffer;
  596.         ASCBuffer2 = ASCBuffer +1L + intDriver->MDelay*2L;
  597.     }
  598.     else
  599.     {
  600.         ASCBuffer2 = ASCBuffer +1L;
  601.         ASCBuffer1 = ASCBuffer + intDriver->MDelay*2L;
  602.     }
  603.     
  604.     
  605.     if( (Ptr) SndBuffer + 2L + 2*(long) ((aCC + aDD * intDriver->ASCBUFFER)>>BYTEDIV) >= curVoice->maxPtr)
  606.     {
  607.         if( intDriver->DriverSettings.Interpolation)
  608.         {
  609.             long    RightWeight, LeftWeight;
  610.             
  611.             while( i-- > 0)
  612.             {
  613.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  614.                 
  615.                 off = aCC>>BYTEDIV;
  616.                 if( SndBuffer + 2*off + 2L >= (char*) curVoice->maxPtr)
  617.                 {
  618.                     if( curVoice->loopSize > 0) 
  619.                     {
  620.                         SndBuffer -= curVoice->loopSize;
  621.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  622.                     }
  623.                     else break;
  624.                 }
  625.                 tByte = (    LeftWeight *     *(SndBuffer + 2*off) +
  626.                             RightWeight *     *(SndBuffer + 2*off + 2)) >> BYTEDIV;            aCC += aDD;
  627.             
  628.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  629.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  630.             }
  631.         }
  632.         else
  633.         {
  634.             while( i-- > 0)
  635.             {
  636.                 off = aCC>>BYTEDIV;
  637.                 if( SndBuffer + 2*off + 2L >= (char*) curVoice->maxPtr)
  638.                 {
  639.                     if( curVoice->loopSize > 0) 
  640.                     {
  641.                         SndBuffer -= curVoice->loopSize;
  642.                         if( SndBuffer + off < curVoice->begPtr) SndBuffer = curVoice->begPtr - off;
  643.                     }
  644.                     else break;
  645.                 }
  646.                 tByte =    *(SndBuffer + 2*off);            aCC += aDD;
  647.                 
  648.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  649.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  650.             }
  651.         }
  652.         
  653.         if( curVoice->loopSize > 0) curVoice->curPtr = (Ptr) (SndBuffer + (long) 2*(long) (aCC>>BYTEDIV));
  654.         else { curVoice->samplePtr    = 0L;    curVoice->curPtr    = curVoice->maxPtr;    }
  655.     }
  656.     else
  657.     {
  658.         if( intDriver->DriverSettings.Interpolation)
  659.         {
  660.             long    RightWeight, LeftWeight;
  661.             
  662.             while( i-- > 0)
  663.             {
  664.                 RightWeight = aCC & ((1 << BYTEDIV) - 1);        LeftWeight = (1 << BYTEDIV) - RightWeight;
  665.                 
  666.                 off = aCC>>BYTEDIV;
  667.                 tByte = (    LeftWeight *     *(SndBuffer + 2*off) +
  668.                             RightWeight *     *(SndBuffer + 2*off + 2)) >> BYTEDIV;            aCC += aDD;
  669.             
  670.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  671.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  672.             }
  673.         }
  674.         else
  675.         {
  676.             while( i-- > 0)
  677.             {
  678.                 off = aCC>>BYTEDIV;
  679.                 tByte =    *(SndBuffer + 2*off);            aCC += aDD;
  680.                 
  681.                 *ASCBuffer1 += *(VolPtr + tByte);        ASCBuffer1 += 2;
  682.                 *ASCBuffer2 += *(VolPtr2 + tByte);        ASCBuffer2 += 2;
  683.             }
  684.         }
  685.         
  686.         curVoice->curPtr = (Ptr) (SndBuffer + 2*(long) (aCC>>BYTEDIV));
  687.     }
  688.     
  689.     curVoice->lAC = aCC & ((1 << BYTEDIV) - 1);
  690. }
  691.  
  692. void Sample8BufferAddDelay( Channel *curVoice, register short *ASCBuffer, MADDriverRec *intDriver)
  693. {
  694.     if( curVoice->amp == 16) Sampler8in16AddDelay( curVoice, ASCBuffer, intDriver);
  695.     else Sampler8in8AddDelay( curVoice, ASCBuffer, intDriver);
  696. }
  697.  
  698. void Play8StereoDelay( MADDriverRec *intDriver)
  699. {
  700. long            i;
  701. short            *ttt;
  702. Ptr                ASCBuffer;
  703.  
  704.     for( i = 0 ; i < intDriver->DriverSettings.numChn; i++) Sample8BufferAddDelay    ( &intDriver->chan[i], intDriver->DASCBuffer8, intDriver);
  705.  
  706.     ttt = intDriver->DASCBuffer8;
  707.     ASCBuffer = intDriver->IntDataPtr;
  708.  
  709.     i = intDriver->ASCBUFFER*2;
  710.     while( i-- > 0)
  711.     {
  712.         *ASCBuffer++ = *(intDriver->OverShoot + *ttt);
  713.         *ttt++ = 0;
  714.     }
  715. }
  716.